Análise exploratória
Modelo de classificação e Rankeamento
Análise de agrupamentos
Repositório completo: GitHub
Clientes sem nenhum tipo de saldo parecem mais insatisfeitos.
anzc_saldo = AddNonZeroCount(prefix="saldo")
anzc_saldo = anzc_saldo.fit(df)
df = anzc_saldo.transform(df)
col = "non_zero_count_saldo"
cv.binaryhistplot(x=df[col], hue=df["TARGET"], nbins=15)
Pouco poder de discriminação.
cs_saldo = CustomSum(prefix="saldo")
cs_saldo = cs_saldo.fit(df)
df = cs_saldo.transform(df)
col = "sum_of_saldo"
min_sum = df[col].min()
cv.binaryhistplot(
x=df[col].apply(lambda x: np.log(x+1-min_sum)),
hue=df["TARGET"],
nbins=10
)
Mesmas observações que saldo.
Pouco poder de discriminação.
anzc_imp = AddNonZeroCount(prefix="imp")
anzc_imp = anzc_imp.fit(df)
df = anzc_imp.transform(df)
col = "non_zero_count_imp"
cv.binaryhistplot(df[col], df["TARGET"], nbins=10)
Pouco poder de discriminação.
cs_imp = CustomSum(prefix="imp")
cs_imp = cs_imp.fit(df)
df = cs_imp.transform(df)
col = "sum_of_imp"
cv.binaryhistplot(df["sum_of_imp"].apply(lambda x: np.log(x + 1)), df["TARGET"], nbins=15)
Uma discussão mais profunda sobre o tema de valores faltantes e preprocessamento pode ser encontrada no notebook de origem do código acima.
Correlação na ocorrência mostra relação entre variáveis com nomes semelhantes (oportunidade de melhorias no projeto).
# Biblioteca missingno, disponível no PyPi
mno.matrix(df[delta_cols])
plt.show()
mno.dendrogram(df[delta_cols])
plt.show()
Pouco poder de discriminação.
anc_delta = AddNoneCount(prefix="delta")
anc_delta = anc_delta.fit(df)
df = anc_delta.transform(df)
col = "none_count_delta"
cv.binaryhistplot(df[col], df["TARGET"], nbins=5)
Pouco poder de discriminação.
anzc_delta = AddNonZeroCount(prefix="delta")
anzc_delta = anzc_delta.fit(df)
df = anzc_delta.transform(df)
col = "non_zero_count_delta"
cv.binaryhistplot(df[col], df["TARGET"], nbins=7)
Pouco poder de discriminação.
cs_delta = CustomSum(prefix="delta")
cs_delta = cs_delta.fit(df)
df = cs_delta.transform(df)
col = "sum_of_delta"
cv.binaryhistplot(df[col], df["TARGET"], nbins=8)
Distribuições parecidas, mas com centros ligeiramente distantes. Não foram realizados testes de hipótese para validar a significância estatística deste (e de outros) deslocamento(s), o que poderia ser um ponto de melhoria no estudo.
anzc_ind = AddNonZeroCount(prefix="ind")
anzc_ind = anzc_ind.fit(df)
df = anzc_ind.transform(df)
col = "non_zero_count_ind"
cv.binaryhistplot(df[col], df["TARGET"], nbins=15)
Aparenta ter bom poder de discriminação.
anzc_num = AddNonZeroCount(prefix="num")
anzc_num = anzc_num.fit(df)
df = anzc_num.transform(df)
col = "non_zero_count_num"
cv.binaryhistplot(
df[col].apply(np.log1p),
df["TARGET"],
nbins=15
)
Também aparenta ter bom poder de discriminação.
cs_num = CustomSum(prefix="num")
cs_num = cs_num.fit(df)
df = cs_num.transform(df)
col = "sum_of_num"
cv.binaryhistplot(
df[col].apply(np.log1p),
df["TARGET"],
nbins=16
)
Classes pouco frequentes: abordagem diferente para cada algorítmo. Nenhuma classe de proporção de insatisfeitos maior que a da classe mais frequente é populosa o suficiente nem tem proporção de insatisfeitos tão maior que a da classe mais frequente para ser considerada relevante.
Outra variável que possui valores faltantes (-999999) e que também não parece ter poder de discriminação. Como lidar com estes valores varia entre o algorítmo implementado, como discutido anteriormente e no notebook de origem do código abaixo (seção de delta).
Pela distribuição, aparenta ser uma variável numérica discreta com forte assimetria à direita.
col = "var3"
cv.binaryhistplot(df[col], df["TARGET"], nbins=50)
Esta variável parece contínua mas tem apenas valores inteiros. Sua distribuição é bem diferente entre as classes da variável de interesse, podendo ser uma boa preditora.
col = "var15"
cv.binaryhistplot(df[col], df["TARGET"], nbins=20)
Variável numérica com forte assimetria à direita. Seu poder de predição não parece tão forte quanto o de var15, mas pode ser muito útil na análise de clusters por ter boa variabilidade.
var = "var38"
cv.binaryhistplot(
df[var].apply(np.log1p),
df["TARGET"],
nbins=20
)
Uma função recebe o conjunto de treino, um pipeline de classificação e uma malha de hiperparâmetros, executa a sequência de fit do wrapper para então serializar e armazenar a instância da classe com pickle para uso posterior.
Além disso, um scipt para construção dos pipelines de processamento de dados foi criado para facilitar a manutenção e reutilização de código.
O primeiro modelo testado foi o Random Forest. Após validação cruzada com GridSearchCV, o pipeline de classificação foi o seguinte:
Percebe-se que foi adicionado um passo para remover variáveis quase constantes. Por mais que pudessem agregar poder de discriminação, inflar o modelo com dados esparsos – além de ser custoso computacionalmente – obriga que o número de variáveis sorteadas por split seja aumentado para que o modelo consiga selecionar variáveis relevantes, o que pode levar a overfitting.
Mesmo assim, o modelo ainda precisou de um número muito alto de variáveis aleatórias para conseguir selecionar as relevantes, o que pode ter prejudicado sua performance no conjunto de testes. Numa futura iteração deste estudo, o thresh do descartador de colunas poderia ser testado junto com os demais hiperparâmetros – outra vantagem de trabalhar com transformadores customizados.
Com número de estimadores fixado em 500 e class_weight em balanced (para arcar com o desbalanceamento), foram testados os seguintes hiperparâmetros:
Sendo que o algoritmo que executou o treinamento foi o seguinte:
O segundo modelo testado foi a implementação do Gradient Boosting de árvores baseado em histogramas do sklearn. Essa implementação é inspirada no LightGBM e foi escolhida apenas por consistência.
Para este classificador, foram testados os seguintes hiperparâmetros:
Sendo que o algoritmo que executou o treinamento foi o seguinte:
Em termos de machine learning, a performance dos modelos é dada por:
Já em termos de negócios:
O modelo campeão é aquele que maximiza o lucro resultante da campanha, que é o objetivo do projeto. Assim, o modelo campeão é o HGB. A malha de hiperparâmetros passada para o HBG foi muito maior (11 vezes mais combinações), de modo que a comparação poderia ser considerada injusta. Contudo, é preciso considerar também o custo computacionalde cada modelo. Com o HGB discretizando as variáveis numéricas, a quantidade de splits testados é drasticamente reduzida, o que acelera o treinamento. Num cenário real onde treinar os modelos também acarreta custo, o HGB é ainda mais vantajoso.
Como se pode perceber, foram poucas as variáveis que contribuíram positivamente para o modelo. Uma próxima etapa no desenvolvimento do modelo antes da implementação seria utilizar apenas estas variáveis, eliminando ruído e reduzindo o custo computacional envolvido. O modelo de Random Forest principalmente se beneficiaria muito desta redução, dada a sua natureza aleatória de sortear variáveis em cada split de cada árvore.
Percebe-se que de modo geral as features criadas contribuíram positivamente para o modelo, mostrando a importância da análise exploratória para o desenvolvimento do modelo mesmo sem conhecimento do que cada variável original representa.
Algumas variáveis criadas se mostraram ruidosas, indicando que o modelo pode ter sido sobreajustado. Este comportamento também se repetiu em diversas variáveis originais (vide o documento original da classificação). Reduzir o número de features poderia ser uma solução, mas também seria interessante testar uma malha de hiperparâmetros com penalizações mais severas, principalmente considerando que a maior penalização testada foi a selecionada no GridSearchCV.
Usando o mesmo modelo de HGB carregado anteriormente, os clientes foram rankeados com base na probabilidade de insatisfação. O corte de classificação do rank 1 é o mesmo do modelo em si, enquanto os demais são steps iguais entre 0 e o corte original.
Antes realizar qualquer tipo de análise, recuperamos o modelo de classificação para atribuir o lucro de cada cliente da base de testes, mas concatenamos o conjunto de testes com o conjunto de treino, preenchendo o lucro de cada cliente deste com np.nan para que forneçam volume nos dados mas não causem viés na análise.
Como o conjunto é dado por variáveis numéricas, os algorítmos usados serão agrupamentos baseados em distância. Sem conhecimento do que realmente é cada variável, não é possível tomar decisões baseadas em conhecimento da área.
A primeira etapa para determinar o processamento dos dados e sua preparação para a clusterização foi recuperar o pipeline de processamento de dados usado na classificação e aplicá-lo novamente.
Em seguida, foi avaliada a esparsidade das features. A tabela abaixo mostra a quantidade de colunas em cada faixa de concentração (%) de valores iguais a zero.
Como a faixa de 40% não possui nenhuma variável, este valor foi definido para reduzir o número de variáveis do modelo, permitindo uma análise mais minusciosa das restantes.
ss = StandardScaler()
pdft = pd.concat(
[
pd.DataFrame(
ss.fit_transform(pdf),
columns=pdf.columns
),
reference
],
axis=1
)
long_df = pdft \
.melt(
id_vars="TARGET",
value_vars=remaining,
var_name="variable",
value_name="value"
)
plt.figure(figsize=(10, 30))
sns.violinplot(
long_df,
x="value",
y="variable",
)
plt.show()
Após a seleção e análise das variáveis restantes, foi construído o seguinte pipeline de processamento de dados:
Sendo o scree plot do PCA:
expl_var(prep[-1].explained_variance_ratio_)
80% of variance is explained by 9 componentsÉ importante ressaltar que embora a primeira componente explique muito bem a variabilidade do conjunto, foi necessário manter 9 componentes principais para que a variância explicada chegasse a 80% (valor comumente utilizado neste tipo de análise). Assim, a visualização dos dados não é tão simples.
Abaixo, a distribuição das 3 componentes principais:
long_df = tdf \
.melt(
id_vars="TARGET",
value_vars=[0, 1, 2],
var_name="variable",
value_name="value"
)
sns.violinplot(
long_df,
x="variable",
y="value",
)
plt.show()
No gráfico de dispersão, vemos a distribuição da variável de interesse nas 3 componentes principais.
Datas as distribuições das 3 componentes principais, optou-se por utilizar o K-Means como algoritmo de agrupamento. Abaixo, temos o gráfico de cotovelo para determinar o número de clusters.
ssd = []
for num_clusters in range(1, 31):
kmeans = KMeans(n_clusters=num_clusters, random_state=42, n_init='auto')
kmeans.fit(tdf[[i for i in range(0,10)]])
ssd.append(kmeans.inertia_)
plt.figure(figsize=(10,6))
plt.plot(range(1, 31), ssd, marker='o', linestyle='--')
plt.xlabel('Number of Clusters')
plt.ylabel('Sum of Squared Distances')
plt.title('Elbow Method For Optimal Number of Clusters')
plt.show()
Determinando o número de clusters como 9, temos a distribuição dos clientes nos clusters:
Com os grupos ordenados por lucro, temos:
Este estudo foi realizado com o objetivo de maximizar o lucro de uma campanha de retenção. Para isso, foram realizadas análises exploratórias, desenvolvidos modelos de classificação e rankeamento e realizada uma análise de agrupamentos naturais. Com conhecimento de mercado, seria possível usar os clusters para direcionar ações específicas para cada grupo de clientes, usando o modelo de classificação para determinar quais estariam de fato insatisfeitos. Nenhum modelo aqui estaria pronto para a produção e outros passos (como feature selection mais rigoroso e análise exploratória mais cuidadosa) poderiam ser adicionados para garantir a robustez do modelo final. Foi possível criar um modelo de classificação lucrativo e encontrar agrupamentos bem definidos, ainda criando margens de observação para clientes possivelmente insatisfeitos com base no rankeamento. Agradeço os envolvidos no processo pela oportunidade de participar do Data Masters e espero que este estudo gere boas discussões acerca do tema.
Felipe Viacava